C:/Projekte/RAIS/dataaccesslayertest/LocalizationTest.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
using RAIS.Common.Localization;
using RAIS.DataAccessLayer;
using Cultures = System.Collections.Generic.Dictionary<string, RAIS.Common.Localization.Culture>;
using Contexts = System.Collections.Generic.Dictionary<string, RAIS.Common.Localization.Context>;
using TranslationItems = System.Collections.Generic.Dictionary<string, RAIS.Common.Localization.TranslationItem>;

namespace RAIS.DataAccessLayerTest
{
        [TestFixture]
        public class LocalizationTest
        {
                #region Properties
                [Test]
                public void Cultures()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        int expectedCount = 3;
                        bool returnStatus;
                        string errorMessage = "";

                        Culture[] expectedCultures = new Culture[expectedCount];
                        for (int i = 1; i <= expectedCount; i++)
                        {
                                expectedCultures[i - 1] = new Culture(i);
                                returnStatus = Localisation.AddCulture(expectedCultures[i - 1], ref errorMessage);
                                if (!returnStatus)
                                        throw new Exception("Add culture error");
                        }

                        // Test
                        Cultures checkCultures = Localisation.SupportedLanguages;

                        // Checks
                        for (int i = 1; i <= expectedCount; i++)
                                Assert.AreEqual(expectedCultures[i - 1].EnglishName, checkCultures[expectedCultures[i - 1].Name].EnglishName);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");
                }
                [Test]
                public void Contexts()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        string[] expectedContexts = { "Context 1", "Context 2", "Context 3" };
                        int expectedCount = expectedContexts.Length;
                        Culture sourceCulture = TestUtilities.NewTestCultureWithSave(1);
                        Culture targetCulture = TestUtilities.NewTestCultureWithSave(2);

                        for (int i = 0; i < expectedCount; i++)
                                // usp_GetTranslation stored procedure adds new culture and row in Translation table
                                // if it does not find the translation and return empty recordset. 
                                // Translate method throw an exception "... can not be translated" in this case
                                // We need to add new cultures in this test, so, ignore the exception
                                try
                                {
                                        Localisation.Translate(expectedContexts[i], "Add", sourceCulture.Name, targetCulture.Name);
                                }
                                catch 
                                { 
                                }

                        // Test
                        Contexts checkContexts = Localisation.Contexts;

                        // Checks
                        for (int i = 0; i < expectedCount; i++)
                                Assert.AreEqual(expectedContexts[i], checkContexts[expectedContexts[i]].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");
                }
                #endregion

                #region Methods
                [Test]
                public void Translate()
                {
                        /*// Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        string errorMessage = "";
                        string expectedContext = "Context 1";
                        Culture sourceLanguage = Localisation.SupportedLanguages["English"];
                        Culture targetLanguage = TestUtilities.NewTestCultureWithSave(1);
                        string testTranslation = "Test Translation";
                        string expectedTranslationResult = "Expected Translation Result";
                        //Add new culture
                        try
                        {
                                Localisation.Translate(expectedContext, testTranslation, sourceLanguage.Name, targetLanguage.Name);

                        }
                        catch
                        {
                        }
                        Context culture = Localisation.Contexts[expectedContext];
                        TranslationItems translationItems = Localisation.GetTranslationsByContext(culture, sourceLanguage, targetLanguage, true);
                        translationItems[expectedContext + " " + testTranslation].TargetText = expectedTranslationResult;
                        Assert.IsTrue(Localisation.SaveTranslations(translationItems, ref errorMessage), "Preparation for test - save translation error");

                        // Test
                        string checkTranslation = Localisation.Translate(expectedContext, testTranslation, sourceLanguage.Name, targetLanguage.Name);

                        // Check
                        Assert.AreEqual(expectedTranslationResult, checkTranslation);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");*/
                }
                [Test]
                public void AddCulture()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        int expectedLCID = 1;
                        bool returnStatus;
                        string errorMessage = "";

                        Culture expectedCulture = new Culture(expectedLCID);

                        // Test
                        returnStatus = Localisation.AddCulture(expectedCulture, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "AddCulture return status:");

                        Culture checkCulture = Localisation.SupportedLanguages[expectedCulture.Name];

                        Assert.AreEqual(expectedCulture.ID, checkCulture.ID);
                        Assert.AreEqual(expectedCulture.Name, checkCulture.Name);
                        Assert.AreEqual(expectedCulture.LCID, checkCulture.LCID);
                        Assert.AreEqual(expectedCulture.EnglishName, checkCulture.EnglishName);
                        Assert.AreEqual(expectedCulture.RightToLeft, checkCulture.RightToLeft);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");
                }
                [Test]
                public void SaveCulture()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        int expectedLCID = 1;
                        bool returnStatus;
                        string errorMessage = "";

                        Culture expectedCulture = new Culture(expectedLCID);
                        returnStatus = Localisation.AddCulture(expectedCulture, ref errorMessage);
                        if (!returnStatus)
                                throw new Exception("Add culture error");

                        expectedCulture.RightToLeft = true;

                        // Test
                        returnStatus = Localisation.SaveCulture(expectedCulture, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "AddCulture return status:");

                        Culture checkCulture = Localisation.SupportedLanguages[expectedCulture.Name];

                        Assert.AreEqual(expectedCulture.RightToLeft, checkCulture.RightToLeft);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");
                }
                [Test]
                [ExpectedException(typeof(System.Collections.Generic.KeyNotFoundException))]
                public void DeleteCulture()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        int expectedLCID = 1;
                        bool returnStatus;
                        string errorMessage = "";

                        Culture expectedCulture = new Culture(expectedLCID);
                        returnStatus = Localisation.AddCulture(expectedCulture, ref errorMessage);
                        if (!returnStatus)
                                throw new Exception("Add culture error");

                        // Test
                        returnStatus = Localisation.DeleteCulture(expectedCulture, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "DeleteCulture return status:");

                        // Check that expectedCulture does not exist in SupportedLanguages dictionary
                        // Expected exception System.Collections.Generic.KeyNotFoundException
                        Culture checkCulture = Localisation.SupportedLanguages[expectedCulture.Name];

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");
                }
                [Test]
                public void GetAllTranslations_WithTranslated()
                {
                        /*// Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        string errorMessage = "";
                        string[] expectedContexts = { "Context 1", "Context 2", "Context 3" };
                        string[] expectedTextToTranslate = { "Text To Translate 1", "Text To Translate 2", "Text To Translate 3" };
                        int expectedCount = expectedContexts.Length;
                        Culture sourceCulture = Localisation.SupportedLanguages["English"];
                        Culture targetCulture = TestUtilities.NewTestCultureWithSave(2);
                        string expectedTranslationResult = "Expected Translation Result";

                        for (int i = 0; i < expectedCount; i++)
                                // usp_GetTranslation stored procedure adds new culture and row in Translation table
                                // if it does not find the translation and return empty recordset. 
                                // Translate method throw an exception "... can not be translated" in this case
                                // We need to add new cultures in this test, so, ignore the exception
                                try
                                {
                                        Localisation.Translate(expectedContexts[i], expectedTextToTranslate[i], sourceCulture.Name, targetCulture.Name);
                                }
                                catch
                                {
                                }
                        Context culture = Localisation.Contexts[expectedContexts[1]];
                        TranslationItems translationItems = Localisation.GetTranslationsByContext(culture, sourceCulture, targetCulture, true);
                        translationItems[expectedContexts[1] + " " + expectedTextToTranslate[1]].TargetText = expectedTranslationResult;
                        Assert.IsTrue(Localisation.SaveTranslations(translationItems, ref errorMessage), "Preparation for test - save translation error");

                        // Test
                        TranslationItems checkTranslationItems = Localisation.GetAllTranslations(sourceCulture, targetCulture, false);

                        // Checks
                        Assert.AreEqual(expectedCount, checkTranslationItems.Count);

                        for (int i = 0; i < expectedCount; i++)
                                Assert.AreEqual(expectedTextToTranslate[i]
                                        , checkTranslationItems[expectedContexts[i] + " " + expectedTextToTranslate[i]].SourceText);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");*/
                }
                [Test]
                public void GetAllTranslations_UntranslatedOnly()
                {
                        /*// Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        string errorMessage = "";
                        string[] expectedContexts = { "Context 1", "Context 2", "Context 3" };
                        string[] expectedTextToTranslate = { "Text To Translate 1", "Text To Translate 2", "Text To Translate 3" };
                        int allTranslationsCount = expectedContexts.Length;
                        int expectedCount = allTranslationsCount - 1;
                        Culture sourceCulture = Localisation.SupportedLanguages["English"];
                        Culture targetCulture = TestUtilities.NewTestCultureWithSave(2);
                        string expectedTranslationResult = "Expected Translation Result";

                        for (int i = 0; i < allTranslationsCount; i++)
                                // usp_GetTranslation stored procedure adds new culture and row in Translation table
                                // if it does not find the translation and return empty recordset. 
                                // Translate method throw an exception "... can not be translated" in this case
                                // We need to add new cultures in this test, so, ignore the exception
                                try
                                {
                                        Localisation.Translate(expectedContexts[i], expectedTextToTranslate[i], sourceCulture.Name, targetCulture.Name);
                                }
                                catch
                                {
                                }
                        Context culture = Localisation.Contexts[expectedContexts[0]];
                        TranslationItems translationItems = Localisation.GetTranslationsByContext(culture, sourceCulture, targetCulture, true);
                        translationItems[expectedContexts[0] + " " + expectedTextToTranslate[0]].TargetText = expectedTranslationResult;
                        Assert.IsTrue(Localisation.SaveTranslations(translationItems, ref errorMessage), "Preparation for test - save translation error");

                        // Test
                        TranslationItems checkTranslationItems = Localisation.GetAllTranslations(sourceCulture, targetCulture, true);

                        // Checks
                        Assert.AreEqual(expectedCount, checkTranslationItems.Count);

                        for (int i = 1; i < allTranslationsCount; i++)
                                Assert.AreEqual(expectedTextToTranslate[i]
                                        , checkTranslationItems[expectedContexts[i] + " " + expectedTextToTranslate[i]].SourceText);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");*/
                }
                [Test]
                public void GetTranslationsByContext_WithTranslated()
                {
                        /*// Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        string errorMessage = "";
                        string expectedContext = "Context";
                        string[] expectedTextToTranslate = { "Text To Translate 1", "Text To Translate 2", "Text To Translate 3" };
                        int allTranslationsCount = expectedTextToTranslate.Length;
                        int expectedCount = allTranslationsCount;
                        Culture sourceCulture = Localisation.SupportedLanguages["English"];
                        Culture targetCulture = TestUtilities.NewTestCultureWithSave(2);
                        string expectedTranslationResult = "Expected Translation Result";

                        for (int i = 0; i < allTranslationsCount; i++)
                                // usp_GetTranslation stored procedure adds new culture and row in Translation table
                                // if it does not find the translation and return empty recordset. 
                                // Translate method throw an exception "... can not be translated" in this case
                                // We need to add new cultures in this test, so, ignore the exception
                                try
                                {
                                        Localisation.Translate(expectedContext, expectedTextToTranslate[i], sourceCulture.Name, targetCulture.Name);
                                }
                                catch
                                {
                                }
                        Context culture = Localisation.Contexts[expectedContext];
                        TranslationItems translationItems = Localisation.GetAllTranslations(sourceCulture, targetCulture, true);
                        translationItems[expectedContext + " " + expectedTextToTranslate[0]].TargetText = expectedTranslationResult;
                        Assert.IsTrue(Localisation.SaveTranslations(translationItems, ref errorMessage), "Preparation for test - save translation error");

                        // Test
                        TranslationItems checkTranslationItems = Localisation.GetTranslationsByContext(culture, sourceCulture, targetCulture, false);

                        // Checks
                        Assert.AreEqual(expectedCount, checkTranslationItems.Count);

                        for (int i = 1; i < allTranslationsCount; i++)
                                Assert.AreEqual(expectedTextToTranslate[i]
                                        , checkTranslationItems[expectedContext + " " + expectedTextToTranslate[i]].SourceText);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");*/
                }
                /*[Test]
                public void GetTranslationsByContext_UntranslatedOnly()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        string errorMessage = "";
                        string expectedContext = "Context";
                        string[] expectedTextToTranslate = { "Text To Translate 1", "Text To Translate 2", "Text To Translate 3" };
                        int allTranslationsCount = expectedTextToTranslate.Length;
                        int expectedCount = allTranslationsCount - 1;
                        Culture sourceCulture = Localisation.SupportedLanguages["English"];
                        Culture targetCulture = TestUtilities.NewTestCultureWithSave(2);
                        string expectedTranslationResult = "Expected Translation Result";

                        for (int i = 0; i < allTranslationsCount; i++)
                                // usp_GetTranslation stored procedure adds new culture and row in Translation table
                                // if it does not find the translation and return empty recordset. 
                                // Translate method throw an exception "... can not be translated" in this case
                                // We need to add new cultures in this test, so, ignore the exception
                                try
                                {
                                        Localisation.Translate(expectedContext, expectedTextToTranslate[i], sourceCulture.Name, targetCulture.Name);
                                }
                                catch
                                {
                                }
                        Context culture = Localisation.Contexts[expectedContext];
                        TranslationItems translationItems = Localisation.GetAllTranslations(sourceCulture, targetCulture, true);
                        translationItems[expectedContext + " " + expectedTextToTranslate[0]].TargetText = expectedTranslationResult;
                        Assert.IsTrue(Localisation.SaveTranslations(translationItems, ref errorMessage), "Preparation for test - save translation error");

                        // Test
                        TranslationItems checkTranslationItems = Localisation.GetTranslationsByContext(culture, sourceCulture, targetCulture, true);

                        // Checks
                        Assert.AreEqual(expectedCount, checkTranslationItems.Count);

                        for (int i = 1; i < allTranslationsCount; i++)
                                Assert.AreEqual(expectedTextToTranslate[i]
                                        , checkTranslationItems[expectedContext + " " + expectedTextToTranslate[i]].SourceText);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");
                }
                [Test]
                public void SaveTranslations()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table before test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";
                        string expectedContext = "Context 1";
                        Culture sourceLanguage = Localisation.SupportedLanguages["English"];
                        Culture targetLanguage = TestUtilities.NewTestCultureWithSave(1);
                        string testTranslation = "Test Translation";
                        string expectedTranslationResult = "Expected Translation Result";
                        //Add new culture
                        try
                        {
                                Localisation.Translate(expectedContext, testTranslation, sourceLanguage.Name, targetLanguage.Name);

                        }
                        catch
                        {
                        }
                        Context culture = Localisation.Contexts[expectedContext];
                        TranslationItems translationItems = Localisation.GetTranslationsByContext(culture, sourceLanguage, targetLanguage, true);
                        translationItems[expectedContext + " " + testTranslation].TargetText = expectedTranslationResult;

                        // Test
                        returnStatus = Localisation.SaveTranslations(translationItems, ref errorMessage);

                        // Check
                        Assert.IsTrue(returnStatus, "Save translation error");

                        string checkTranslation = Localisation.Translate(expectedContext, testTranslation, sourceLanguage.Name, targetLanguage.Name);
                        Assert.AreEqual(expectedTranslationResult, checkTranslation);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTable("Translation"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.TruncateTable("Context"), "Clear [Translation] table after test error");
                        Assert.IsTrue(TestUtilities.DeleteTestCultures(), "Delete cultures after test error");
                }*/
                #endregion
        }
}